could we use isNullableClass instead? That way null won't pollute our patterns when -Yexplicit-nulls is enabled.

also, for exhaustiveness we don't report missing nulls, so maybe it's fine to do the same for unreachability?

scala> final case class Foo(x: Int)
// defined case class Foo

scala> def foo(x: Foo) = x match { case Foo(_) => }
def foo(x: Foo): Unit

scala> foo(null)
scala.MatchError: null

actually I guess we should emit a warning _ only matches null like we already do for case _ =>

We have a feature that reports a warning if the last wildcard only matches null (#4253 (comment)). I think removing the null related stuff will make the code simpler.

actually I guess we should emit a warning _ only matches null like we already do for case _ =>

That would make the check more complex and expensive, while not very useful to users. I think removing null related logic will produce expected and helpful warnings to users while keeping the logic simple and fast.

Actually, we can avoid computing precisely whether a pattern covers exactly null. Instead, we can blindly provide a hint for null if the last case is _ and is unreachable. This allows us to use Typ(tp) instead of Or(Type(tp), nullSpace) for a wildcard pattern.

Doing that simplifies the code, and uncovers a bug that I'm now investigating:

object Test {
  sealed trait Cause[+E]

  object Cause {
    final case class Fail[E](value: E) extends Cause[E]
  }

  def fn(cause: Cause[Any]): String =
    cause match {
      case Cause.Fail(t: Throwable) => t.toString
      case Cause.Fail(any)          => any.toString
    }
}

Previously no warning is produced because the checker thought that 2nd case matches Fail(null), which is incorrect.

We now issue a warning here (see the check file).